home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / sys5 / iscwmpst.z / iscwmpst / tcp / src / arpcmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-17  |  4.9 KB  |  238 lines
  1. /* @(#) $Header: arpcmd.c,v 1.8 91/07/16 17:54:50 deyke Exp $ */
  2.  
  3. /* ARP commands
  4.  * Copyright 1991, Phil Karn, KA9Q
  5.  */
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include "global.h"
  9. #include "mbuf.h"
  10. #include "timer.h"
  11. #include "enet.h"
  12. #include "ax25.h"
  13. #include "arp.h"
  14. #include "netuser.h"
  15. #include "cmdparse.h"
  16. #include "commands.h"
  17.  
  18. static int doarpadd __ARGS((int argc,char *argv[],void *p));
  19. static int doarpdrop __ARGS((int argc,char *argv[],void *p));
  20. static int doarpflush __ARGS((int argc,char *argv[],void *p));
  21. static void dumparp __ARGS((void));
  22.  
  23. static struct cmds Arpcmds[] = {
  24.     "add", doarpadd, 0, 4,
  25.     "arp add <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  26.  
  27.     "drop", doarpdrop, 0, 3,
  28.     "arp drop <hostid> ether|ax25|netrom|arcnet",
  29.  
  30.     "flush", doarpflush, 0, 0,
  31.     NULLCHAR,
  32.  
  33.     "publish", doarpadd, 0, 4,
  34.     "arp publish <hostid> ether|ax25|netrom|arcnet <ether addr|callsign>",
  35.  
  36.     NULLCHAR,
  37. };
  38. char *Arptypes[] = {
  39.     "NET/ROM",
  40.     "10 Mb Ethernet",
  41.     "3 Mb Ethernet",
  42.     "AX.25",
  43.     "Pronet",
  44.     "Chaos",
  45.     "",
  46.     "Arcnet",
  47.     "Appletalk"
  48. };
  49.  
  50. int
  51. doarp(argc,argv,p)
  52. int argc;
  53. char *argv[];
  54. void *p;
  55. {
  56.     if(argc < 2){
  57.         dumparp();
  58.         return 0;
  59.     }
  60.     return subcmd(Arpcmds,argc,argv,p);
  61. }
  62. static
  63. doarpadd(argc,argv,p)
  64. int argc;
  65. char *argv[];
  66. void *p;
  67. {
  68.     int16 hardware;
  69.     int32 addr;
  70.     char *hwaddr;
  71.     struct arp_tab *ap;
  72.     struct arp_type *at;
  73.     int pub = 0;
  74.  
  75.     if(argv[0][0] == 'p')   /* Is this entry published? */
  76.         pub = 1;
  77.     if((addr = resolve(argv[1])) == 0){
  78.         tprintf(Badhost,argv[1]);
  79.         return 1;
  80.     }
  81.     /* This is a kludge. It really ought to be table driven */
  82.     switch(tolower(argv[2][0])){
  83.     case 'n':       /* Net/Rom pseudo-type */
  84.         hardware = ARP_NETROM;
  85.         break;
  86.     case 'e':       /* "ether" */
  87.         hardware = ARP_ETHER;
  88.         break;
  89.     case 'a':       /* "ax25" */
  90.         switch(tolower(argv[2][1])) {
  91.         case 'x':
  92.             hardware = ARP_AX25;
  93.             break;
  94.         case 'r':
  95.             hardware = ARP_ARCNET;
  96.             break;
  97.         default:
  98.             tprintf("unknown hardware type \"%s\"\n",argv[2]);
  99.             return -1;
  100.         }
  101.         break;
  102.     case 'm':       /* "mac appletalk" */
  103.         hardware = ARP_APPLETALK;
  104.         break;
  105.     default:
  106.         tprintf("unknown hardware type \"%s\"\n",argv[2]);
  107.         return -1;
  108.     }
  109.     /* If an entry already exists, clear it */
  110.     if((ap = arp_lookup(hardware,addr)) != NULLARP)
  111.         arp_drop(ap);
  112.  
  113.     at = &Arp_type[hardware];
  114.     if(at->scan == NULLFP){
  115.         tprintf("Attach device first\n");
  116.         return 1;
  117.     }
  118.     /* Allocate buffer for hardware address and fill with remaining args */
  119.     hwaddr = mallocw(at->hwalen);
  120.     /* Destination address */
  121.     (*at->scan)(hwaddr,argv[3]);
  122.     ap = arp_add(addr,hardware,hwaddr,pub); /* Put in table */
  123.     free(hwaddr);                           /* Clean up */
  124.     stop_timer(&ap->timer);                 /* Make entry permanent */
  125.     set_timer(&ap->timer,0L);
  126.     return 0;
  127. }
  128. /* Remove an ARP entry */
  129. static
  130. doarpdrop(argc,argv,p)
  131. int argc;
  132. char *argv[];
  133. void *p;
  134. {
  135.     int16 hardware;
  136.     int32 addr;
  137.     struct arp_tab *ap;
  138.  
  139.     if((addr = resolve(argv[1])) == 0){
  140.         tprintf(Badhost,argv[1]);
  141.         return 1;
  142.     }
  143.     /* This is a kludge. It really ought to be table driven */
  144.     switch(tolower(argv[2][0])){
  145.     case 'n':
  146.         hardware = ARP_NETROM;
  147.         break;
  148.     case 'e':       /* "ether" */
  149.         hardware = ARP_ETHER;
  150.         break;
  151.     case 'a':       /* "ax25" */
  152.         switch(tolower(argv[2][1])) {
  153.         case 'x':
  154.             hardware = ARP_AX25;
  155.             break;
  156.         case 'r':
  157.             hardware = ARP_ARCNET;
  158.             break;
  159.         default:
  160.             hardware = 0;
  161.             break;
  162.         }
  163.         break;
  164.     case 'm':       /* "mac appletalk" */
  165.         hardware = ARP_APPLETALK;
  166.         break;
  167.     default:
  168.         hardware = 0;
  169.         break;
  170.     }
  171.     if((ap = arp_lookup(hardware,addr)) == NULLARP)
  172.         return -1;
  173.     arp_drop(ap);
  174.     return 0;
  175. }
  176. /* Flush all automatic entries in the arp cache */
  177. static int
  178. doarpflush(argc,argv,p)
  179. int argc;
  180. char *argv[];
  181. void *p;
  182. {
  183.     register struct arp_tab *ap;
  184.     struct arp_tab *aptmp;
  185.     int i;
  186.  
  187.     for(i=0;i<HASHMOD;i++){
  188.         for(ap = Arp_tab[i];ap != NULLARP;ap = aptmp){
  189.             aptmp = ap->next;
  190.             if(dur_timer(&ap->timer) != 0)
  191.                 arp_drop(ap);
  192.         }
  193.     }
  194.     return 0;
  195. }
  196.  
  197. /* Dump ARP table */
  198. static void
  199. dumparp()
  200. {
  201.     register int i;
  202.     register struct arp_tab *ap;
  203.     char e[128];
  204.  
  205.     arp_loadfile();
  206.     tprintf("received %u badtype %u bogus addr %u reqst in %u replies %u reqst out %u\n",
  207.      Arp_stat.recv,Arp_stat.badtype,Arp_stat.badaddr,Arp_stat.inreq,
  208.      Arp_stat.replies,Arp_stat.outreq);
  209.  
  210.     tprintf("IP addr            Type              Time Q Addr\n");
  211.     for(i=0;i<HASHMOD;i++){
  212.         for(ap = Arp_tab[i];ap != (struct arp_tab *)NULL;ap = ap->next){
  213.             tprintf("%-18.18s ",inet_ntoa(ap->ip_addr));
  214.             tprintf("%-15s",smsg(Arptypes,NHWTYPES,ap->hardware));
  215.             tprintf("%7ld ",read_timer(&ap->timer)/1000L);
  216.             if(ap->state == ARP_PENDING)
  217.                 tprintf("%-2u",len_q(ap->pending));
  218.             else
  219.                 tprintf("  ");
  220.             if(ap->state == ARP_VALID){
  221.                 if(Arp_type[ap->hardware].format != NULL){
  222.                     (*Arp_type[ap->hardware].format)(e,ap->hw_addr);
  223.                 } else {
  224.                     e[0] = '\0';
  225.                 }
  226.                 tprintf("%s",e);
  227.             } else {
  228.                 tprintf("[unknown]");
  229.             }
  230.             if(ap->pub)
  231.                 tprintf(" (published)");
  232.             if(tprintf("\n") == EOF)
  233.                 return;
  234.         }
  235.     }
  236.     return;
  237. }
  238.